package services

import (
	"errors"
	"game-server/app/common/request"
	"game-server/app/common/response"
	"game-server/app/models"
	"game-server/global"
)

type tagService struct{}

var TagService = new(tagService)

// 获取标签列表
func (s *tagService) GetTagList(params request.TagListRequest) (response.ListResponse[models.Tag], error) {
	var res response.ListResponse[models.Tag]
	var tags []models.Tag

	query := global.App.DB.Model(&models.Tag{})

	if params.Name != "" {
		query = query.Where("name LIKE ?", "%"+params.Name+"%")
	}

	query.Count(&res.Total)

	offset := (params.Page - 1) * params.PageSize
	err := query.Offset(offset).
		Limit(params.PageSize).
		Order("id DESC").
		Find(&tags).Error

	if err != nil {
		return res, err
	}

	res.List = tags
	return res, nil
}

// 创建标签
func (s *tagService) CreateTag(params request.TagAddRequest) error {
	var count int64
	global.App.DB.Model(&models.Tag{}).Where("name = ?", params.Name).Count(&count)
	if count > 0 {
		return errors.New("标签名称已存在")
	}

	return global.App.DB.Create(&models.Tag{
		Name: params.Name,
		Img:  params.Img,
	}).Error
}

// 更新标签
func (s *tagService) UpdateTag(params request.TagUpdateRequest) error {
	var tag models.Tag
	if err := global.App.DB.First(&tag, params.ID).Error; err != nil {
		return errors.New("标签不存在")
	}

	var count int64
	global.App.DB.Model(&models.Tag{}).Where("name = ? AND id != ?", params.Name, params.ID).Count(&count)
	if count > 0 {
		return errors.New("标签名称已存在")
	}

	tag.Name = params.Name
	tag.Img = params.Img
	return global.App.DB.Save(&tag).Error
}

// 删除标签
func (s *tagService) DeleteTag(params request.TagDelRequest) error {
	// 检查标签是否被游戏使用
	var count int64
	global.App.DB.Model(&models.GameTag{}).Where("tag_id =?", params.ID).Count(&count)
	if count > 0 {
		//先删除游戏标签关联
		if err := global.App.DB.Where("tag_id =?", params.ID).Delete(&models.GameTag{}).Error; err != nil {
			return err
		}
		// return errors.New("标签已被游戏使用，无法删除")
	}
	return global.App.DB.Delete(&models.Tag{}, params.ID).Error
}

// GetAllTags 获取所有标签
func (s *tagService) GetAllTags() ([]models.Tag, error) {
	var tags []models.Tag
	err := global.App.DB.Model(&models.Tag{}).Order("id DESC").Find(&tags).Error
	return tags, err
}

// GetAllTags 获取所有标签
func (s *tagService) TagFrontAll() ([]models.TageListResponse, error) {
	var tagsResponse []models.TageListResponse

	// 使用左连接和分组计数来一次性获取标签及其游戏数量
	err := global.App.DB.Table("tags").
		Select("tags.*, COALESCE(COUNT(game_tags.game_id), 0) as game_count").
		Joins("LEFT JOIN game_tags ON tags.id = game_tags.tag_id").
		Group("tags.id").
		Order("tags.id DESC").
		Scan(&tagsResponse).Error

	if err != nil {
		return nil, err
	}

	return tagsResponse, nil
}

// GetAllTags 获取所有标签
func (s *tagService) TagFrontList(params request.TagFrontListRequest) (response.ListResponse[models.TageListResponse], error) {
	var res response.ListResponse[models.TageListResponse]
	var tagsResponse []models.TageListResponse

	query := global.App.DB.Table("tags").
		Select("tags.*, COALESCE(COUNT(game_tags.game_id), 0) as game_count").
		Joins("LEFT JOIN game_tags ON tags.id = game_tags.tag_id").
		Where("tags.deleted_at IS NULL"). // 添加软删除条件
		Group("tags.id")

	// 获取总数
	var total int64
	global.App.DB.Model(&models.Tag{}).Where("deleted_at IS NULL").Count(&total)
	res.Total = total

	// 分页查询
	offset := (params.Page - 1) * params.PageSize
	err := query.Offset(offset).
		Limit(params.PageSize).
		Order("tags.id DESC").
		Scan(&tagsResponse).Error

	if err != nil {
		return res, err
	}

	res.List = tagsResponse
	return res, nil
}

// GetTagGameList 获取标签下的游戏列表
func (s *tagService) GetTagGameList(params request.TagGameListRequest) (response.ListResponse[models.Game], error) {
	var res response.ListResponse[models.Game]
	var games []models.Game

	query := global.App.DB.Model(&models.Game{}).
		Joins("JOIN game_tags ON games.id = game_tags.game_id").
		Where("game_tags.tag_id = ? AND games.deleted_at IS NULL", params.ID)
	// Preload("Tags").
	// Preload("ScreenShots").
	// Preload("GameVideos").
	// Preload("Category")

	// 获取总数
	query.Count(&res.Total)

	// 分页查询
	offset := (params.Page - 1) * params.PageSize
	err := query.Offset(offset).
		Limit(params.PageSize).
		Order("games.id DESC").
		Find(&games).Error

	if err != nil {
		return res, err
	}

	res.List = games
	return res, nil
}

// 根据id获取tag
func (s *tagService) GetTagById(id uint) (models.Tag, error) {
	var tag models.Tag
	err := global.App.DB.Model(&models.Tag{}).Where("id = ?", id).First(&tag).Error
	return tag, err
}

// BatchAddGame 批量添加游戏到标签
func (s *tagService) BatchAddGame(params request.TagBatchAddGameRequest) error {
	// 检查标签是否存在
	var tag models.Tag
	if err := global.App.DB.First(&tag, params.TagID).Error; err != nil {
		return errors.New("标签不存在")
	}

	// 检查游戏是否存在
	var games []models.Game
	if err := global.App.DB.Where("id IN ?", params.IDS).Find(&games).Error; err != nil {
		return errors.New("游戏不存在")
	}

	// 检查游戏是否已经添加到标签
	var existingGameTags []models.GameTag
	if err := global.App.DB.Where("tag_id =? AND game_id IN?", params.TagID, params.IDS).Find(&existingGameTags).Error; err != nil {
		return err
	}

	// 构建要添加的游戏标签关系
	var gameTags []models.GameTag
	for _, game := range games {
		// 检查游戏是否已经添加到标签
		var exists bool
		for _, existingGameTag := range existingGameTags {
			if existingGameTag.GameId == game.ID.ID {
				exists = true
				break
			}
		}
		if !exists {
			gameTags = append(gameTags, models.GameTag{
				TagId:  params.TagID,
				GameId: game.ID.ID,
			})
		}

	}
	// 批量添加游戏标签关系
	return global.App.DB.Create(&gameTags).Error
}
